package com.app.xinfadi.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Environment;
import android.util.Base64;

import com.app.xinfadi.base.Constant;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;


public class FileUtil {
    private final static String TAG = "FileUtil";

    /*
         * 写入信息到文件
         */
    public static void WriteToFile(Context context, String fileName, String data, int mode) {
        FileOutputStream fOut = null;
        OutputStreamWriter osw = null;
        try {
            fOut = context.openFileOutput(fileName, mode);
            osw = new OutputStreamWriter(fOut);
            osw.write(data);
            osw.flush();
            // Toast.makeText(context, "信息已经保存",Toast.LENGTH_SHORT).show();
        } catch (Exception e) {
            e.printStackTrace();
            // Toast.makeText(context, "信息已经未保存",Toast.LENGTH_SHORT).show();
        } finally {
            try {
                osw.close();
                fOut.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static boolean IsExist(String sPath) {
        File file = new File(sPath);
        if (file.exists()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 删除文件
     *
     * @param sPath 文件路径
     * @return
     */
    public static boolean DeleteFolder(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 判断目录或文件是否存在
        if (!file.exists()) { // 不存在返回 false
            return flag;
        } else {
            // 判断是否为文件
            if (file.isFile()) { // 为文件时调用删除文件方法
                return deleteFile(sPath);
            } else { // 为目录时调用删除目录方法
                return deleteDirectory(sPath);
            }
        }
    }

    /**
     * 删除单个文件
     *
     * @param sPath 被删除文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     * 删除目录（文件夹）以及目录下的文件
     *
     * @param sPath 被删除目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String sPath) {
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        // 删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            } // 删除子目录
            else {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag)
            return false;
        // 删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Base64转String
     *
     * @param str
     * @return
     */
    public static String getFromBASE64(String str) {
        if (str == null)
            return null;
        try {
            byte[] decode = Base64.decode(str, Base64.DEFAULT);
            return new String(decode);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 计算文件或者文件夹的大小 ，单位 MB
     *
     * @param file 要计算的文件或者文件夹 ， 类型：java.io.File
     * @return 大小，单位：MB
     */
    public static double getSize(File file) {
        // 判断文件是否存在
        if (file.exists()) {
            // 如果是目录则递归计算其内容的总大小，如果是文件则直接返回其大小
            if (!file.isFile()) {
                // 获取文件大小
                File[] fl = file.listFiles();
                double ss = 0;
                for (File f : fl)
                    ss += getSize(f);
                return ss;
            } else {
                double ss = (double) file.length() / 1024 / 1024;
                return ss;
            }
        } else {
            // System.out.println("文件或者文件夹不存在，请检查路径是否正确！");
            return 0.0;
        }
    }

    /*
     * 从sdCard中加载图片
     */
    public static byte[] findFlie(String fileName, String folder) {
        byte[] result = null;
        FileInputStream in = null;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        System.out.println("Environment.getExternalStorageState()--->" + Environment.getExternalStorageState());
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {

            File file = Environment.getExternalStorageDirectory();
            String sd_file = file.getAbsolutePath() + folder + fileName;
            System.out.println("读取的时候的路径" + sd_file);
            if (new File(sd_file).exists()) {
                try {

                    in = new FileInputStream(sd_file);
                    int len = 0;
                    while ((len = in.read()) != -1) {
                        out.write(len);

                    }
                    out.flush();
                    result = out.toByteArray();

                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    if (out != null) {
                        try {
                            out.close();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        } else {
            System.out.println("SdCard的状态不是mounted");
        }
        return result;
    }

    /*
     * 写入到sd卡中
     */
    public static boolean writeToEx(String key, byte[] valus) {
        boolean flag = false;
        FileOutputStream fileOutputStream = null;
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            try {
                File sdcard_file = Environment.getExternalStorageDirectory();// 获得sdcard的目录
                // 创建目录
                String folder = "/M/";
                File file = new File(sdcard_file, folder);
                if (!file.exists()) {
                    file.mkdirs();
                }
                key = key.replace("://", ".").replace("/", ".");
                String absolute_path = sdcard_file.getAbsolutePath() + folder + key;
                fileOutputStream = new FileOutputStream(absolute_path);
                fileOutputStream.write(valus, 0, valus.length);
                fileOutputStream.flush();
                flag = true;
                System.out.println("sdCard成功写入！");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fileOutputStream != null) {
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } else {
            System.out.println("当前sdCard的状态不是挂载状态！");
        }
        return flag;
    }

    /**
     * 获取sd卡绝对路径
     */
    public static String getSDPath() {
        File sdDir = null;
        boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); // 判断sd卡是否存在
        if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory();// 获取跟目录
        }
        return sdDir.toString();
    }

    /*
     * 将Bitmap转换成byte[]
     */
    public static byte[] BitmapToBytes(Bitmap bm) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.PNG, 100, baos);// png类型
        return baos.toByteArray();
    }

    // 写到sdcard中
    public static boolean writeBytesToSd(byte[] bs, String filePath) {
        try {
            FileOutputStream out = new FileOutputStream(new File(filePath));
            out.write(bs);
            out.flush();
            out.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 创建不存在的文件夹
     *
     * @param path
     * @return
     */
    public static boolean MakeFile(String path) {
        File filePath = new File(path);
        if (!filePath.exists()) {
            // 如果无法创建
            if (!filePath.mkdirs()) {
                LogUtil.e(TAG, "创建失败！");
                return false;
            } else
                LogUtil.e(TAG, "创建成功！");
            return true;
        }
        return true;
    }

    /**
     * 创建 app 基础目录 /app名
     *
     * @return
     */
    public static boolean MakeBaseBathFile() {
        File file = new File(Constant.BASE_PATH);
        Boolean success = false;
        if (!file.exists()) {
            success = file.mkdir();
        }
        return success;
    }

    /**
     * 创建 images 缓存文件 基础目录 /app名/images
     *
     * @return
     */
    public static boolean MakeImagesFile() {
        Boolean success = false;
        File imagesFile = new File(Constant.IMAGE_SAVE_PATH);
        if (!imagesFile.exists()) {
            success = imagesFile.mkdirs();
        }
        return success;
    }
}
